package com.gyt.manage.function.airthmetic;

import com.alibaba.fastjson.JSON;
import org.apache.commons.lang3.ArrayUtils;
import org.assertj.core.util.Lists;
import org.junit.Test;

import java.io.File;
import java.util.*;
import java.util.stream.Collectors;

public class BaseArithmetic {

    @Test
    public void testBubble(){
        int[] array = {1,3,8,4,7,9,2};
        List<Integer> list = Arrays.asList(ArrayUtils.toObject(array));
        List<Integer> collect = Arrays.stream(array).boxed().collect(Collectors.toList());
        Collections.sort(collect);
        System.out.println(JSON.toJSONString(collect));
        Collections.sort(list);
        System.out.println(JSON.toJSONString(list));
        sortBubble(array);
        System.out.println(JSON.toJSONString(array));
    }

    @Test
    public void testPrimeNum(){
        List<Integer> list = primeNum(1000);
        System.out.println("size"+list.size()+";list:"+JSON.toJSONString(list));
    }

    @Test
    public void testRecursion(){
        String path = "D:\\logs";
        recursionFile(path);
    }

    @Test
    public void testNoRepeatNum(){
        List<Integer> list = noRepeat(4);
        System.out.println("size:"+list.size()+";list:"+JSON.toJSONString(list));
    }


    @Test
    public void testMath(){
        //一个整数，它加上100后是一个完全平方数，加上168又是一个完全平方数，请问该数是多少？
        for (long i = 0; i < Long.MAX_VALUE; i++) {
            if (Math.sqrt(i+100)%1 == 0 && Math.sqrt(i +168)%1 == 0){
                System.out.println(i);
                break;
            }
        }
    }
    /**
     * 有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
     * 123,124,132,134,142,143;213,214,231,234,241,243;
     * 312,314,321,324,341,342;412,413,421,423,431,432
     */
    public List<Integer> noRepeat(int x){
        List<Integer> list =Lists.newArrayList();
        if (x <= 1)
            return list;
        for (int i = 1; i <= x; i++) {
            for (int j = 1; j <= x; j++) {
                if (i ==j)continue;
                for (int n = 1; n <= x; n++) {
                    if (j == n || i == n)continue;
                    int num = i * 100 + j * 10 + n;
                    list.add(num);
                }
            }
        }
        return list;
    }

    /**
     * 递归输出文件目录下所有文件
     * @param path
     */
    public void recursionFile(String path){
        File f = new File(path);
        File[] files = f.listFiles();
        if (files != null && files.length > 0){
            for (File file : files) {
                if (file.isFile()) {
                    System.out.println(file.getPath());
                }else {
                    recursionFile(file.getPath());
                }
            }
        }
    }

    /**
     * 输出一个数（含该数）以内的质数
     * @param num
     * @return
     */
    public List<Integer>  primeNum(int num){
        List<Integer> list = Lists.newArrayList();
        for (int i = 1; i <= num; i++) {
            if (i <= 1) continue;
            if (i == 2) { list.add(i);continue; }
            if (!(i % 2 ==0 || i % 3 == 0 || i % 5 == 0)) {
                list.add(i);
            }
        }
        return list;
    }
    /**
     * 冒泡法排序
     * 对数组进行排序，冒泡排序法的原理就是将一组无序数组进行排序，同过把值较小的数逐渐向数组的顶部（即朝第一个元素）冒出来，
     * 就像水中的气泡上升一样。同时，值较大的数据逐渐向数组的底部（即朝最后一个元素）沉下去。这种算法用嵌套的循环对整个数组进行数次遍历，
     * 每次遍历都要比较数组中相邻的一对元素，如果这对元素以升序（或者值相等）的顺序排列，那么保持它们的位置不变；
     * 如果这对元素以降序的顺序排列，那么交换他们的值。
     */
    public void sortBubble(int[] array){
        for (int i = 1; i < array.length; i++) {//第一个for循环表示第几次循环
            for (int j = 0; j < array.length-1; j++) {//第二个for循环表示该次循环进行几次比较
                if (array[j]>array[j+1]) {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }
}
